<?php
namespace App\Support;
use Illuminate\Support\Facades\Redis;

class Myredis
{
    private static $instance;

    private function __construct(){}

    private function __clone(){}

    public static function getInstance()
    {
        if (!(self::$instance instanceof self)) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    /*
     * 存储单个 key 对应的 value
     */
    public function set($key, $value)
    {
        return Redis::set($key, $value);
    }

    /*
     * 获取单个 key 对应的 value
     */
    public function get($key)
    {
        return Redis::get($key);
    }

    /*
     * 存储多个 key 对应的 value
     */
    public function mset($key, $value)
    {
        return Redis::mset($key, $value);
    }

    /*
     * 获取多个 key 对应的 value
     */
    public function mget(array $key)
    {
        return Redis::mget($key);
    }

    /*
     * 存放带存储时效的记录
     */
    public function setex($key, $timeout, $value)
    {
        return Redis::setex($key, $timeout, $value);
    }

    /*
     * 检测是否存在值
     */
    public function exists($key)
    {
        return Redis::exists($key);
    }


    /*
     * 删除
     */
    public function del($key)
    {
        return Redis::del($key);
    }

    /*
    * 结果返回替换前的值
    */
    public function getset($key)
    {
        return Redis::getset($key);
    }

    /*
     * 递增
     */
    public function incr($key)
    {
        return Redis::incr($key);
    }

    /*
    * 按给定值递增
    */
    public function incrby($key, $value)
    {
        return Redis::incrby($key, $value);
    }

    /*
    * 递减
    */
    public function decr($key)
    {
        return Redis::decr($key);
    }

    /*
    * 按给定值递减
    */
    public function decrby($key, $value)
    {
        return Redis::decrby($key, $value);
    }

    /*
    * 连接到已存在字符串
    */
    public function append($key, $value)
    {
        return Redis::append($key, $value);
    }

    /*
     * 部分替换操作, 并返回字符串长度,$start 起始点
     */
    public function setrange($key, $start, $value)
    {
        return Redis::setrange($key, $start, $value);
    }

    /*
    * 部分获取操作, 并返回字符串长度,$start 起始点 $end 截止点
    * $redis->substr('str', 0, 2); // 返回'abc'; 表示从第 0 个起，取到第 2 个字符
    */
    public function substr($key, $start, $end)
    {
        return Redis::substr($key, $start, $end);
    }

    /*
    * 获取字符串长度
    * $redis->strlen ('str'); // 返回 4; 此时 'str' 为 'abcd'
    */
    public function strlen($key)
    {
        return Redis::strlen($key);
    }

    /*
    * 模糊查找功能,支持 * 号以及 ? 号 (匹配一个字符) $redis->keys('f?o?');
    */
    public function keys($key)
    {
        return Redis::keys($key);
    }

    /*
    * 随机返回一个key
    */
    public function randomkey()
    {
        return Redis::randomkey();
    }

    /*
    * 对key进行改名 $redis->rename('str', 'str2'); // 把原先命名为'str'的 key 改成了 'str2'
    */
    public function rename($key1, $key2)
    {
        return Redis::rename($key1, $key2);
    }

    /*
    * 对key进行改名，不允许改成已存在的key
    */
    public function renamenx($key1, $key2)
    {
        return Redis::renamenx($key1, $key2);
    }

    /*
    * expire 设置 key-value 的时效性  $redis->expire('foo', 10);  // 设置有效期为 10 秒
    */
    public function expire($key, $timeout)
    {
        return Redis::expire($key, $timeout);
    }

    /*
    * 获取剩余有效期  $redis->ttl('foo');  // 返回剩余有效期值 10 秒
    */
    public function ttl($key)
    {
        return Redis::ttl($key);
    }

    /*
    * 获取剩余有效期  $redis->ttl('foo');  // 返回剩余有效期值 10 秒
    */
    public function persist($key)
    {
        return Redis::persist($key);
    }

    /*
    * 返回redis当前数据库的记录总数
    */
    public function dbsize()
    {
        return Redis::dbsize();
    }

    //------------------------------------队列操作---------------------------------------


    //rpush/rpushx 有序列表操作,从队列后插入元素；lpush/lpushx 和 rpush/rpushx 的区别是插入到队列的头部,
    //同上,'x'含义是只对已存在的 key 进行操作

    /*
    * 返回列表长度
    */
    public function rpush($key, $value)
    {
        return Redis::rpush($key, $value);
    }

    /*
    * 返回列表长度
    */
    public function rpushx($key, $value)
    {
        return Redis::rpushx($key, $value);
    }

    /*
    * 返回列表长度
    */
    public function lpush($key, $value)
    {
        return Redis::lpush($key, $value);
    }

    /*
    * 返回列表长度
    */
    public function lpushx($key, $value)
    {
        return Redis::lpushx($key, $value);
    }

    /*
    * 返回当前列表长度
    */
    public function llen($key)
    {
        return Redis::llen($key);
    }

    /*
    * 返回队列中一个区间的元素
    * $redis->lrange ('fooList', 0, 1);  // 返回数组包含第 0 个至第 1 个, 共2个元素
    * $redis->lrange ('fooList', 0, -1); //返回第0个至倒数第一个, 相当于返回所有元素
    */
    public function lrange($key, $start, $end)
    {
        return Redis::lrange($key, $start, $end);
    }

    /*
    * 返回指定顺序位置的 list 元素
    * $redis->lindex('fooList', 1) ; // 返回'bar1'
    */
    public function lindex($key, $index)
    {
        return Redis::lindex($key, $index);
    }

    /*
    * 修改队列中指定位置的value
    * $redis->lset('fooList', 1, '123'); // 修改位置 1 的元素, 返回 true
    */
    public function lset($key, $index, $value)
    {
        return Redis::lset($key, $index, $value);
    }

    /*
    * 删除队列中左起指定数量的字符
    *$redis->lrem('fooList', 1, '_') ; // 删除队列中左起(右起使用-1) 1个 字符'_'(若有)
    */
    public function lrem($key, $start, $str)
    {
        return Redis::lrem($key, $start, $str);
    }

    /*
    * 类似栈结构地弹出(并删除)最左或最右的一个元素
    *$redis->lpop('fooList') ;  // 返回 'bar0'
    */
    public function lpop($key)
    {
        return Redis::lpop($key);
    }

    /*
    * 类似栈结构地弹出(并删除)最左或最右的一个元素
    *$redis->rpop('fooList') ;  // 返回 'bar2'
    */
    public function rpop($key)
    {
        return Redis::rpop($key);
    }

    /*
    * 队列修改，保留左边起若干元素，其余删除
    *$redis->ltrim('fooList', 0, 1) ; // 保留左边起第 0 个至第 1 个元素
    */
    public function ltrim($key, $start, $end)
    {
        return Redis::ltrim($key, $start, $end);
    }

    /*
    * 从一个队列中 pop 出元素并 push 到另一个队列
    *$redis->rpush('list1', 'ab0');
    *$redis->rpush('list1', 'ab1');
    *$redis->rpush('list2', 'ab2');
    *$redis->rpush('list2', 'ab3');
    *$redis->rpoplpush('list1', 'list2'); // 结果list1 =>array('ab0'), list2 =>array('ab1','ab2','ab3')
    *$redis->rpoplpush('list2', 'list2'); // 也适用于同一个队列, 把最后一个元素移到头部 list2 =>array('ab3','ab1','ab2')
    */
    public function rpoplpush($key1, $key2)
    {
        return Redis::rpoplpush($key1, $key2);
    }

    /*
     * 在队列的中间指定元素前或后插入元素
     *$redis->linsert('list2', 'before', 'ab1', '123');  //表示在元素 'ab1' 之前插入 '123'
     *$redis->linsert('list2', 'after', 'ab1', '456');   //表示在元素 'ab1' 之后插入 '456'
     */
    public function linsert($key, $operate = 'after', $value1, $value2)
    {
        return Redis::linsert($key, $operate, $value1, $value2);
    }

    /*
     * 阻塞并等待一个列队不为空时，再pop出最左或最右的一个元素（这个功能在php以外可以说非常好用）
     *$redis->blpop('list3', 10) ; // 如果 list3 为空则一直等待,直到不为空时将第一元素弹出, 10 秒后超时
     */
    public function blpop($key, $timeout)
    {
        return Redis::blpop($key, $timeout);
    }

    //---------------------------------集合操作-----------------------------------


    /*
     * 增加set集合元素， 返回true， 重复返回false
     *$redis->sadd('set1', 'ab');
     */
    public function sadd($key, $value)
    {
        return Redis::sadd($key, $value);
    }

    /*
     * 移除指定元素
     *$redis->srem('set1', 'cd'); // 删除'cd'元素
     */
    public function srem($key, $value)
    {
        return Redis::srem($key, $value);
    }

    /*
     * 弹出首元素
     *$redis->spop('set1'); // 返回 'ab'
     */
    public function spop($key)
    {
        return Redis::spop($key);
    }

    /*
     *  移动当前set集合的指定元素到另一个set集合
     *$redis->sadd('set2', '123');
     *$redis->smove('set1', 'set2', 'ab'); // 移动'set1'中的'ab'到'set2', 返回true or false；此时 'set1'集合不存在 'ab' 这个值
     */
    public function smove($key1, $key2, $value)
    {
        return Redis::smove($key1, $key2, $value);
    }

    /*
     * 返回当前set表元素个数
     *$redis->scard('set2'); // 返回 2
     */
    public function scard($key)
    {
        return Redis::scard($key);
    }

    /*
     * 判断元素是否属于当前set集合
     *$redis->sismember('set2', '123'); // 返回 true or false
     */
    public function sismember($key, $value)
    {
        return Redis::sismember($key, $value);
    }

    /*
     * 返回当前set集合的所有元素
     *$redis->smembers('set2'); // 返回 array('123','ab')
     */
    public function smembers($key)
    {
        return Redis::smembers($key);
    }

    /*
     * sinter/sunion/sdiff 返回两个表中元素的交集/并集/补集
     *$redis->sadd('set1', 'ab') ;
     *$redis->sinter('set2', 'set1') ;  //返回array('ab')
     */
    public function sinter($key1, $key2)
    {
        return Redis::sinter($key1, $key2);
    }

    /*
     * sinter/sunion/sdiff 返回两个表中元素的交集/并集/补集
     *$redis->sadd('set1', 'ab') ;
     *$redis->sinter('set2', 'set1') ;  //返回array('ab')
     */
    public function sunion($key1, $key2)
    {
        return Redis::sunion($key1, $key2);
    }

    /*
     * sinter/sunion/sdiff 返回两个表中元素的交集/并集/补集
     *$redis->sadd('set1', 'ab') ;
     *$redis->sinter('set2', 'set1') ;  //返回array('ab')
     */
    public function sdiff($key1, $key2)
    {
        return Redis::sdiff($key1, $key2);
    }

    /*
     * sinterstore/sunionstore/sdiffstore 将两个表交集/并集/补集元素 copy 到第三个表中
     *$redis->set('foo', 0);
     *$redis->sinterstore('foo', 'set1');  // 等同于将'set1'的内容copy到'foo'中，并将'foo'转为set表
     *$redis->sinterstore('foo', array('set1', 'set2'));  // 将'set1'和'set2'中相同的元素 copy 到'foo'表中, 覆盖'foo'原有内容
     */
    public function sinterstore($key1, $key2)
    {
        return Redis::sinterstore($key1, $key2);
    }

    /*
     * sinterstore/sunionstore/sdiffstore 将两个表交集/并集/补集元素 copy 到第三个表中
     *$redis->set('foo', 0);
     *$redis->sinterstore('foo', 'set1');  // 等同于将'set1'的内容copy到'foo'中，并将'foo'转为set表
     *$redis->sinterstore('foo', array('set1', 'set2'));  // 将'set1'和'set2'中相同的元素 copy 到'foo'表中, 覆盖'foo'原有内容
     */
    public function sunionstore($key1, $key2)
    {
        return Redis::sunionstore($key1, $key2);
    }

    /*
     * sinterstore/sunionstore/sdiffstore 将两个表交集/并集/补集元素 copy 到第三个表中
     *$redis->set('foo', 0);
     *$redis->sinterstore('foo', 'set1');  // 等同于将'set1'的内容copy到'foo'中，并将'foo'转为set表
     *$redis->sinterstore('foo', array('set1', 'set2'));  // 将'set1'和'set2'中相同的元素 copy 到'foo'表中, 覆盖'foo'原有内容
     */
    public function sdiffstore($key1, $key2)
    {
        return Redis::sdiffstore($key1, $key2);
    }


    /*
     * 返回表中一个随机元素
     *$redis->srandmember('set1') ;
     */
    public function srandmember($key)
    {
        return Redis::srandmember($key);
    }

    //---------------------------------有序set表操作----------------------------------

    /*
     *  增加元素，并设置序号，成功返回true，重复返回false
     *$redis->zadd('zset1', 1, 'ab');
     */
    public function zadd($key, $index, $value)
    {
        return Redis::zadd($key, $index, $value);
    }

    /*
     *  对指定元素索引值的增减,改变元素排列次序
     *$redis -> zincrby ( 'zset1' , 10 , 'ab' ) ; //返回11
     */
    public function zincrby($key, $index, $value)
    {
        return Redis::zincrby($key, $index, $value);
    }

    /*
     *  移除指定元素
     *$redis->zrem('zset1', 'ef'); // 返回 true or false
     */
    public function zrem($key, $value)
    {
        return Redis::zrem($key, $value);
    }

    /*
     *  按位置次序返回表中指定区间的元素
     *$redis->zrange('zset1', 0, 1);  // 返回位置 0 和 1 之间(两个)的元素
     *$redis->zrange('zset1', 0, -1); // 返回位置 0 和倒数第一个元素之间的元素(相当于所有元素)
     */
    public function zrange($key, $start, $end)
    {
        return Redis::zrange($key, $start, $end);
    }

    /*
     *  同上,返回表中指定区间的元素,按次序倒排
     *$redis->zrevrange('zset1', 0, -1); // 元素顺序和zrange相反
     */
    public function zrevrange($key, $start, $end)
    {
        return Redis::zrevrange($key, $start, $end);
    }

    /*
     *  zrangebyscore/zrevrangebyscore 按顺序/降序返回表中指定索引区间的元素
     *$redis->zadd('zset1', 3, 'ef');
     *$redis->zadd('zset1', 5, 'gh');
     *$redis->zrangebyscore('zset1', 2, 9);  //返回索引值2-9之间的元素 array('ef','gh')
     *$redis->zrangebyscore('zset1', 2, 9, 'withscores'); // 返回索引值2-9之间的元素并包含索引值 array(array('ef',3),array('gh',5))
     *$redis->zrangebyscore('zset1', 2, 9, array('withscores'=>true, 'limit'=>array(1, 2)));
     *返回索引值2-9之间的元素,'withscores' =>true表示包含索引值; 'limit'=>array(1, 2),表示偏移1条，返回2条,结果为array(array('ef',3),array('gh',5))
     */
    public function zrangebyscore($key, $start, $end, $operate = '')
    {
        return Redis::zrangebyscore($key, $start, $end, $operate);
    }

    /*
     *  同上
     */
    public function zrevrangebyscore($key, $start, $end, $operate = '')
    {
        return Redis::zrevrangebyscore($key, $start, $end, $operate);
    }

    /*
     *  zunionstore/zinterstore 将多个表的并集/交集存入另一个表中
     *$redis->zunionstore('zset3', array('zset1', 'zset2', 'zset0'));  //将'zset1','zset2','zset0'的并集存入'zset3'
     *$redis->zunionstore('zset3', array('zset1', 'zset2'), array('weights' => array(2, 1)));
     * weights参数表示权重，其中表示并集后 zset1集合的分 * 2 后存储到 zset3 集合， zset2集合的分 * 1 后存储到 zset3 集合
     *$redis->zunionstore('zset3', array('zset1', 'zset2'), array('aggregate' => 'max'));
     *'aggregate' => 'max'或'min'表示并集后相同的元素是取大值或是取小值
     */
    public function zunionstore($key1, $key2, $key3)
    {
        return Redis::zunionstore($key1, $key2, $key3);
    }

    /*
     *  同上
     */
    public function zinterstore($key1, $key2, $key3)
    {
        return Redis::zinterstore($key1, $key2, $key3);
    }

    /*
     *  统计一个索引区间的元素个数
     *$redis->zcount('zset1', 3, 5); // 返回 2
     *$redis->zcount('zset1', '(3', 5));  //'(3'表示索引值在3-5之间但不含3,同理也可以使用'(5'表示上限为5但不含5
     */
    public function zcount($key, $start, $end)
    {
        return Redis::zcount($key, $start, $end);
    }

    /*
     *  统计元素个数
     *$redis->zcard('zset1'); // 返回 4
     */
    public function zcard($key)
    {
        return Redis::zcard($key);
    }

    /*
     *  查询元素的索引
     *$redis->zscore('zset1', 'ef'); // 返回 3
     */
    public function zscore($key, $value)
    {
        return Redis::zscore($key, $value);
    }

    /*
     *  删除一个索引区间的元素
     *$redis->zremrangebyscore('zset1', 0, 2); // 删除索引在0-2之间的元素('ab','cd'), 返回删除元素个数2
     */
    public function zremrangebyscore($key, $start, $end)
    {
        return Redis::zremrangebyscore($key, $start, $end);
    }

    /*
     *  zrank/zrevrank 返回元素所在表顺序/降序的位置(不是索引)
     *$redis->zrank('zset1', 'ef'); // 返回0,因为它是第一个元素；zrevrank则返回1(最后一个)
     */
    public function zrank($key, $value)
    {
        return Redis::zrank($key, $value);
    }

    /*
     *  zrank/zrevrank 返回元素所在表顺序/降序的位置(不是索引)
     *$redis->zrank('zset1', 'ef'); // 返回0,因为它是第一个元素；zrevrank则返回1(最后一个)
     */
    public function zrevrank($key, $value)
    {
        return Redis::zrevrank($key, $value);
    }

    /*
     *  删除表中指定位置区间的元素
     *$redis->zremrangebyrank('zset1', 0, 10); //删除位置为0-10的元素,返回删除的元素个数2
     */
    public function zremrangebyrank($key, $start, $end)
    {
        return Redis::zremrangebyrank($key, $start, $end);
    }

    //-----------------------------------Hash表操作--------------------------------------------
    /*
     *  hset/hget 存取hash表的数据
     *$redis->hset('hash1', 'key1', 'v1');  //将key为'key1' value为'v1'的元素存入hash1表
     */
    public function hset($table, $key, $value)
    {
        return Redis::hset($table, $key, $value);
    }

    /*
     *  hset/hget 存取hash表的数据
     *$redis->hget('hash1', 'key1');   //取出表'hash1'中的key 'key1'的值,返回'v1'
     */
    public function hget($table, $key)
    {
        return Redis::hget($table, $key);
    }

    /*
     *  返回hash表中的指定key是否存在
     *$redis->hexists('hash1', 'key1') ; //true or false
     */
    public function hexists($table, $key)
    {
        return Redis::hexists($table, $key);
    }

    /*
     *  删除hash表中指定key的元素
     *$redis->hdel('hash1', 'key2') ; //true or false
     */
    public function hdel($table, $key)
    {
        return Redis::hdel($table, $key);
    }

    /*
     *  返回hash表元素个数
     *$redis->hlen('hash1'); // 返回 1
     */
    public function hlen($table)
    {
        return Redis::hlen($table);
    }

    /*
     *  增加一个元素,但不能重复
     *$redis->hsetnx('hash1', 'key1', 'v2') ;  // false
     *$redis->hsetnx('hash1', 'key2', 'v2') ;  // true
     *$redis->hset('hash1', 'key1', 'v1');  //将key为'key1' value为'v1'的元素存入hash1表
     */
    public function hsetnx($table, $key, $value)
    {
        return Redis::hsetnx($table, $key, $value);
    }


    /*
   *  hmset/hmget 存取多个元素到hash表
   *$redis->hmset('hash1', array('key3' => 'v3', 'key4' => 'v4'));
   *$redis->hmget('hash1', array('key3', 'key4'));  // 返回相应的值 array('v3','v4')
   */
    public function hmset($table, $arr)
    {
        return Redis::hmset($table, $arr);
    }

    /*
     *  hmset/hmget 存取多个元素到hash表
     *$redis->hmset('hash1', array('key3' => 'v3', 'key4' => 'v4'));
     *$redis->hmget('hash1', array('key3', 'key4'));  // 返回相应的值 array('v3','v4')
     */
    public function hmget($table, $arr)
    {
        return Redis::hmget($table, $arr);
    }

    /*
     *  对指定key进行累加
     *$redis->hincrby('hash1', 'key5', 3);  // 不存在，则存储并返回 3；存在，即返回 原有值 + 3；
     *$redis->hincrby('hash1', 'key5', 10);  // 返回13
     */
    public function hincrby($table, $key, $value)
    {
        return Redis::hincrby($table, $key, $value);
    }

    /*
     *  返回hash表中的所有key
     *$redis->hkeys('hash1'); // 返回array('key1', 'key2', 'key3', 'key4', 'key5')
     */
    public function hkeys($table)
    {
        return Redis::hkeys($table);
    }


    /*
     *  返回hash表中的所有value
     *$redis->hvals('hash1'); // 返回 array('v1','v2','v3','v4',13)
     */
    public function hvals($table)
    {
        return Redis::hvals($table);
    }

    /*
     *  返回整个hash表元素
     *$redis->hgetall('hash1'); // 返回 array('key1'=>'v1','key2'=>'v2','key3'=>'v3','key4'=>'v4','key5'=>13)
     */
    public function hgetall($table)
    {
        return Redis::hgetall($table);
    }


    //--------------------------------排序操作-------------------------------------

    /*
     *  sort 排序
     *$redis->rpush('tab', 3);
     *$redis->rpush('tab', 2);
     *$redis->rpush('tab', 17);
     *$redis->sort('tab');   // 返回 array(2,3,17)
     *使用参数,可组合使用 array('sort' => 'desc','limit' => array(1, 2))
     *$redis->sort('tab', array('sort' => 'desc'));   // 降序排列，返回 array(17,3,2)
     *$redis->sort('tab', array('limit' => array(1, 2)));   //返回顺序位置中1的元素2个(这里的2是指个数,而不是位置)，返回array(3,17)
     *$redis->sort('tab', array('limit' => array('alpha' => true)));  //按首字符排序返回array(17,2,3)，因为17的首字符是'1'所以排首位置
     *$redis->sort('tab', array('limit' => array('store' => 'ordered')));  //表示永久性排序，返回元素个数
     *$redis->sort('tab', array('limit' => array('get' => 'pre_*')));  //使用了通配符'*'过滤元素，表示只返回以'pre_'开头的元素
     */
    public function sort($key, $operate = '')
    {
        return Redis::sort($key, $operate);
    }

    //---------------------------------Redis管理操作-------------------------------------

    /*
     *  显示服务当状态信息
     *$redis->info();
     */
    public function info()
    {
        return Redis::info();
    }

    /*
     *  指定要操作的数据库
     *$redis->select(4); // 指定数据库的下标
     */
    public function select($index)
    {
        return Redis::select($index);
    }

    /*
     *  清空当前库
     *$redis->flushdb();
     */
    public function flushdb()
    {
        return Redis::flushdb();
    }

    /*
     *  移动当库的元素到其它数据库
     *$redis->set('tomove', 'bar');
     *$redis->move('tomove', 4);
     */
    public function move($key, $index)
    {
        return Redis::move($key, $index);
    }

    /*
     *  配置从服务器
     *$redis->slaveof('127.0.0.1', 80);  // 配置 127.0.0.1 端口 80 的服务器为从服务器
     *$redis->slaveof();  // 清除从服务器
     */
    public function slaveof($ip = '', $port = '')
    {
        return Redis::slaveof($ip, $port);
    }

    /*
     *  同步保存服务器数据到磁盘
     *$redis->save();
     */
    public function save()
    {
        return Redis::save();
    }

    /*
     *  异步保存服务器数据到磁盘
     *$redis->bgsave();
     */
    public function bgsave()
    {
        return Redis::bgsave();
    }

    /*
     *  返回最后更新磁盘的时间
     *$redis->lastsave();
     */
    public function lastsave()
    {
        return Redis::lastsave();
    }

}

?>
